/**
 * 认证相关工具函数
 */

// 声明uni类型
declare const uni: any

// 存储键名常量
export const STORAGE_KEYS = {
	USER_TOKEN: 'user_token',
	USER_INFO: 'user_info',
	SAVED_USERNAME: 'saved_username',
	SAVED_PASSWORD: 'saved_password'
}

import { userApi } from './api'
// Token过期时间（小时）
const TOKEN_EXPIRE_HOURS = 24

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
export const isLoggedIn = () => {
	try {
		const token = uni.getStorageSync(STORAGE_KEYS.USER_TOKEN)
		const userInfo = uni.getStorageSync(STORAGE_KEYS.USER_INFO)

		if (!token || !userInfo) {
			return false
		}

		// // 检查token是否过期
		// if (isTokenExpired(userInfo.loginTime)) {
		// 	clearLoginData()
		// 	return false
		// }

		return true
	} catch (error) {
		console.error('检查登录状态失败:', error)
		return false
	}
}
export const hasToken = () => {
	return uni.getStorageSync(STORAGE_KEYS.USER_TOKEN)
}

/**
 * 获取当前用户信息
 * @returns {object|null} 用户信息
 */
export const getCurrentUser = () => {
	try {
		if (!isLoggedIn()) {
			return null
		}
		return uni.getStorageSync(STORAGE_KEYS.USER_INFO)
	} catch (error) {
		console.error('获取用户信息失败:', error)
		return null
	}
}

/**
 * 获取当前用户token
 * @returns {string|null} 用户token
 */
export const getCurrentToken = () => {
	try {
		// 直接返回存储的token，让服务器验证token有效性
		return uni.getStorageSync(STORAGE_KEYS.USER_TOKEN)
	} catch (error) {
		console.error('获取用户token失败:', error)
		return null
	}
}

export type UserInfo = {
	name: string
	projects?: [string, string][]
	region_company?: string[]
	role_name?: string,
	phone?: string,
	position: string
	token: string
}

/**
 * 保存登录数据
 * @param {object} userInfo - 用户信息
 * @param {string} token - 用户token
 */
export const saveLoginData = (userInfo: UserInfo, token: string) => {
	//console.log('saveLoginData', userInfo, token)
	try {
		const loginData = {
			...userInfo,
			loginTime: new Date().toISOString()
		}

		console.log("saveLoginData", loginData, token)
		uni.setStorageSync(STORAGE_KEYS.USER_TOKEN, token)
		uni.setStorageSync(STORAGE_KEYS.USER_INFO, loginData)

		//console.log('登录数据保存成功')
	} catch (error) {
		console.error('保存登录数据失败:', error)
		throw error
	}
}

/**
 * 清除登录数据
 */
export const clearLoginData = () => {
	try {
		uni.removeStorageSync(STORAGE_KEYS.USER_TOKEN)
		uni.removeStorageSync(STORAGE_KEYS.USER_INFO)
		console.log('登录数据清除成功')
	} catch (error) {
		console.error('清除登录数据失败:', error)
	}
}

/**
 * 保存记住的登录凭据
 * @param {string} account - 账号
 * @param {string} password - 密码
 */
export const saveCredentials = (account: string, password: string) => {
	try {
		uni.setStorageSync(STORAGE_KEYS.SAVED_USERNAME, account)
		uni.setStorageSync(STORAGE_KEYS.SAVED_PASSWORD, password)
	} catch (error) {
		console.error('保存登录凭据失败:', error)
	}
}

/**
 * 获取保存的登录凭据
 * @returns {object} 包含账号和密码的对象
 */
export const getSavedCredentials = () => {
	try {
		const account = uni.getStorageSync(STORAGE_KEYS.SAVED_USERNAME) || ''
		const password = uni.getStorageSync(STORAGE_KEYS.SAVED_PASSWORD) || ''

		return { account, password }
	} catch (error) {
		console.error('获取保存的登录凭据失败:', error)
		return { account: '', password: '' }
	}
}

/**
 * 清除保存的登录凭据
 */
export const clearSavedCredentials = () => {
	try {
		uni.removeStorageSync(STORAGE_KEYS.SAVED_USERNAME)
		uni.removeStorageSync(STORAGE_KEYS.SAVED_PASSWORD)
	} catch (error) {
		console.error('清除保存的登录凭据失败:', error)
	}
}

export const getProjects = () => {
	const userInfo = uni.getStorageSync(STORAGE_KEYS.USER_INFO)
	if (userInfo && userInfo.projects) {
		console.log('userInfo', userInfo.projects)
		return userInfo.projects.map(([id, name]: [string, string]) => ({
			project_id: id,
			project_name: name
		}))
	}
	return []
}

/**
 * 登出
 */
export const logout = () => {
	try {
		clearLoginData()

		// 显示登出提示
		uni.showToast({
			title: '已退出登录',
			icon: 'success',
			duration: 2000
		})

		// #ifdef H5
		// H5环境下可以刷新页面或跳转到登录页
		setTimeout(() => {
			window.location.reload()
		}, 2000)
		// #endif

		// #ifndef H5
		// 非H5环境下跳转到首页
		uni.reLaunch({
			url: '/pages/home/home'
		})
		// #endif

	} catch (error) {
		console.error('登出失败:', error)
		uni.showToast({
			title: '登出失败',
			icon: 'none'
		})
	}
}

/**
 * 模拟登录API调用
 * @param {object} credentials - 登录凭据
 * @returns {Promise} 登录结果
 */
export const loginApi = (credentials: any) => {
	return userApi.login(credentials).then(res => {
		if (res.success) {
			return { userInfo: res.data, token: res.data.token }
		} else {
			throw new Error(res.message);
		}
	})
}

/**
 * 检查是否需要显示登录框（仅H5环境）
 * @returns {boolean} 是否需要显示登录框
 */
export const shouldShowLoginModal = () => {
	// #ifdef H5
	return !isLoggedIn()
	// #endif

	// #ifndef H5
	return false
	// #endif
}

/**
 * 微信小程序认证（自动获取code和手机号）
 * @returns {Promise} 认证结果
 */
export const wxAuth = () => {
	return new Promise((resolve, reject) => {
		// #ifdef MP-WEIXIN
		// 检查登录状态
		uni.checkSession({
			success() {
				// session_key 未过期，并且在本生命周期一直有效
				if (isLoggedIn()) {
					resolve(getCurrentUser())
					return
				}
				// 有session但本地无登录信息，需要重新认证
				performWxAuth().then(resolve).catch(reject)
			},
			fail() {
				// session_key 已经失效，需要重新执行认证流程
				performWxAuth().then(resolve).catch(reject)
			}
		})
		// #endif

		// #ifndef MP-WEIXIN
		reject(new Error('此功能仅在微信小程序中可用'))
		// #endif
	})
}

/**
 * 执行微信小程序认证流程
 * @returns {Promise} 认证结果
 */
const performWxAuth = () => {
	return new Promise((resolve, reject) => {
		// #ifdef MP-WEIXIN
		// 1. 获取登录凭证（code）
		uni.login({
			provider: 'weixin',
			success(loginRes: any) {
				if (loginRes.code) {
					console.log('获取微信登录code成功:', loginRes.code)
					// 2. 临时保存code，等待用户授权手机号
					tempWxCode = loginRes.code
					resolve({ needPhoneAuth: true, code: loginRes.code })
				} else {
					reject(new Error('获取登录凭证失败'))
				}
			},
			fail(error: any) {
				console.error('微信登录失败:', error)
				reject(new Error('微信登录失败'))
			}
		})
		// #endif
	})
}

// 临时存储微信code
let tempWxCode: string | null = null

/**
 * 处理微信手机号授权
 * @param {Object} phoneDetail - 手机号授权数据
 * @returns {Promise} 处理结果
 */
export const handleWxPhoneAuth = (phoneDetail: any) => {
	return new Promise<UserInfo | null>((resolve, reject) => {
		// #ifdef MP-WEIXIN
		//console.log('处理微信手机号授权:', phoneDetail)

		if (!tempWxCode) {
			console.error('缺少微信登录凭证')
			reject(new Error('请先进行微信认证'))
			return
		}

		if (!phoneDetail) {
			console.error('手机号授权数据为空')
			reject(new Error('获取手机号数据失败'))
			return
		}


		// 检查用户是否拒绝授权
		if (phoneDetail.errMsg === 'getPhoneNumber:fail user deny') {
			reject(new Error('用户拒绝授权获取手机号'))
			return
		}

		// 检查是否没有权限
		if (phoneDetail.errMsg === 'getPhoneNumber:fail no permission') {
			reject(new Error('PERMISSION_REQUIRED'))
			return
		}

		// 检查其他错误
		if (phoneDetail.errMsg && phoneDetail.errMsg.includes('fail')) {
			console.error('手机号授权失败:', phoneDetail.errMsg)
			reject(new Error(`获取手机号失败: ${phoneDetail.errMsg}`))
			return
		}

		// 检查是否授权成功
		if (phoneDetail.errMsg !== 'getPhoneNumber:ok') {
			console.error('手机号授权失败:', phoneDetail.errMsg)
			reject(new Error(`获取手机号失败: ${phoneDetail.errMsg}`))
			return
		}

		// 检查是否有加密数据
		if (!phoneDetail.encryptedData || !phoneDetail.iv) {
			console.error('缺少手机号加密数据')
			reject(new Error('获取手机号加密数据失败'))
			return
		}

		// 调用后端API，发送code和手机号加密数据
		const authData = {
			code: tempWxCode,
			encryptedData: phoneDetail.encryptedData,
			iv: phoneDetail.iv
		}

		//console.log('发送微信认证数据到后端:', authData)

		userApi.wxAuth(authData).then((res: any) => {		
			if (res.success) {
				// 保存登录信息
				const userInfo = {
					...res.data,
					loginTime: new Date().toISOString(),
					loginType: 'wechat'
				}
				console.log("userInfo", userInfo)
				saveLoginData(userInfo, res.data.token)
				tempWxCode = null // 清除临时code
				resolve(userInfo)
			} else {
				reject(new Error(res.message || '微信认证失败'))
			}
		}).catch(error => {
			console.error('微信认证API调用失败:', error)
			reject(new Error('网络错误，请检查网络连接'))
		})
		// #endif
	})
}



/**
 * 检查是否需要进行微信认证
 * @returns {boolean} 是否需要微信认证
 */
export const shouldWxAuth = () => {
	// #ifdef MP-WEIXIN
	return !isLoggedIn()
	// #endif

	// #ifndef MP-WEIXIN
	return false
	// #endif
}

// 检查token是否过期的函数
export const isTokenExpired = (loginTime: string): boolean => {
	if (!loginTime) return true

	try {
		const loginDate = new Date(loginTime)
		const now = new Date()
		const hoursDiff = (now.getTime() - loginDate.getTime()) / (1000 * 60 * 60)

		return hoursDiff > TOKEN_EXPIRE_HOURS
	} catch (error) {
		console.error('检查token过期时间失败:', error)
		return true
	}
}

export default {
	isLoggedIn,
	isTokenExpired,
	getCurrentUser,
	getCurrentToken,
	saveLoginData,
	clearLoginData,
	saveCredentials,
	getSavedCredentials,
	clearSavedCredentials,
	logout,
	loginApi,
	shouldShowLoginModal,
	wxAuth,
	handleWxPhoneAuth,
	shouldWxAuth
} 